home *** CD-ROM | disk | FTP | other *** search
/ BBS in a Box 1 / BBS in a box - Trilogy I.iso / Files / QuickTime / QT Tools / QuickTime Interfacing / MoviesFormat.p < prev    next >
Encoding:
Text File  |  1992-10-20  |  11.9 KB  |  472 lines  |  [TEXT/MPS ]
  1. {************************************************************
  2.  
  3. Created: Monday, August 17, 1992 at 5:13 PM
  4.  MoviesFormat.p
  5.  Pascal Interface to the Macintosh Libraries
  6.  
  7.  
  8.  Copyright Apple Computer, Inc. 1991, 1992
  9.  All rights reserved
  10.  
  11. ************************************************************}
  12.  
  13. {$IFC UNDEFINED UsingIncludes}
  14. {$SETC UsingIncludes := 0}
  15. {$ENDC}
  16.  
  17. {$IFC NOT UsingIncludes}
  18.  UNIT MoviesFormat;
  19.  INTERFACE
  20. {$ENDC}
  21.  
  22. {$IFC UNDEFINED UsingMoviesFormat}
  23. {$SETC UsingMoviesFormat := 1}
  24.  
  25. {$I+}
  26. {$SETC MoviesFormatIncludes := UsingIncludes}
  27. {$SETC UsingIncludes := 1}
  28.  
  29. {$IFC UNDEFINED UsingMovies}
  30. {$I $$Shell(PInterfaces)Movies.p}
  31. {$ENDC}
  32. {$SETC UsingIncludes := MoviesFormatIncludes}
  33.  
  34. CONST
  35. kMovieVersion = 0;                { version number of the format here described }
  36.  
  37.  
  38. {****************************************
  39. *
  40. *   General Types -
  41. *        These types are used in more than one of the
  42. *        directory types.
  43. *
  44. ****************************************}
  45.  
  46. { MoviesUserData is the type used for user data in movie and track directories }
  47.  
  48. TYPE
  49.  
  50. MoviesUserData = RECORD
  51.     size    :    LONGINT;         { size of this user data }
  52.     udType    :    LONGINT;         { type of user data  }
  53.     data    :    PACKED ARRAY[0..0] OF Byte;         { the user data } 
  54. END;
  55.  
  56. UserDataAtom = RECORD
  57.     size        :    LONGINT;    
  58.     atomType    :    LONGINT; 
  59.     userData    :    ARRAY[0..0] OF MoviesUserData;
  60. END;
  61.  
  62.  
  63. { MoviesDataDescription tells us where the data for the movie or track lives.
  64.    The data can follow the directory, be in the datafork of the same file as the directory resource,
  65.    be in the resource fork of the same file as the directory resource, be in another file in the 
  66.    data fork or resource fork, or require a specific bottleneck to fetch the data. }
  67.  
  68.  
  69. {***************************************
  70. *
  71. *   MediaDirectory information -
  72. *        The MediaDirectory is tightly coupled to the data.
  73. *
  74. ***************************************}
  75.  
  76. { The SampleDescriptionTable holds the SampleDescriptions needed to decompress chunks given the
  77.    SampleDescriptionID. There is a table per Media. }
  78.  
  79. {
  80. SampleDescription = RECORD
  81.     size        :    LONGINT;
  82.     dataFormat    :    LONGINT;
  83.     resvd1        :    LONGINT;
  84.     resvdA        :    INTEGER;
  85.     dataRefId    :    INTEGER;
  86. END;
  87. SampleDescriptionHandle = ^^SampleDescription;
  88. }
  89.  
  90. SampleDescriptionAtom = RECORD
  91.     size            :    LONGINT;
  92.     atomType        :    LONGINT;            { = 'stsd' }
  93.     flags            :    LONGINT;            { 1 byte of version / 3 bytes of flags }
  94.     numEntries        :    LONGINT;
  95.     sampleDescTable    :    ARRAY[0..0] OF SampleDescription;
  96. END;
  97.  
  98. { TimeToSampleNum maps physical sample time to physical sample number. }
  99.  
  100. TimeToSampleNum = RECORD
  101.     sampleCount     :    LONGINT;
  102.     sampleDuration    :    TimeValue;
  103. END;
  104.  
  105. TimeToSampleNumAtom = RECORD
  106.     size        :    LONGINT;
  107.     atomType    :    LONGINT;            { = 'stts' }
  108.     flags        :    LONGINT;            { 1 byte of version / 3 bytes of flags }
  109.     numEntries    :    LONGINT;
  110.     timeToSampleNumTable : ARRAY[0..0] OF TimeToSampleNum;
  111. END;
  112.  
  113. { SyncSamples is a list of the physical samples which are self contained. }
  114.  
  115. SyncSampleAtom = RECORD
  116.     size            :    LONGINT;
  117.     atomType        :    LONGINT;        { = 'stss' }
  118.     flags            :    LONGINT;        { 1 byte of version / 3 bytes of flags }
  119.     numEntries        :    LONGINT;
  120.     syncSampleTable    :    ARRAY[0..0] OF LONGINT;
  121. END;
  122.  
  123. SampleToChunk = RECORD
  124.     firstChunk            :    LONGINT;
  125.     samplesPerChunk        :    LONGINT;
  126.     sampleDescriptionID    :    LONGINT;
  127. END;
  128.  
  129. SampleToChunkAtom = RECORD
  130.     size                :    LONGINT;        
  131.     atomType            :    LONGINT;    { = 'stsc' }
  132.     flags                :    LONGINT;    { 1 byte of version / 3 bytes of flags }
  133.     numEntries            :    LONGINT;        
  134.     sampleToChunkTable     :    ARRAY[0..0] OF SampleToChunk;
  135. END;
  136.  
  137. ChunkOffsetAtom = RECORD
  138.     size                :    LONGINT;    
  139.     atomType            :    LONGINT;                { = 'stco' }
  140.     flags                :    LONGINT;                { 1 byte of version / 3 bytes of flags }
  141.     numEntries            :    LONGINT;    
  142.     chunkOffsetTable    :    ARRAY[0..0] OF LONGINT;
  143. END;
  144.  
  145. SampleSizeAtom = RECORD
  146.     size            :    LONGINT;        
  147.     atomType        :    LONGINT;        { = 'stsz' }
  148.     flags            :    LONGINT;        { 1 byte of version / 3 bytes of flags }
  149.     sampleSize        :    LONGINT;        
  150.     numEntries        :    LONGINT;        
  151.     sampleSizeTable :    ARRAY[0..0] OF LONGINT;
  152. END;
  153.  
  154. ShadowSync = RECORD
  155.     fdSampleNum        :    LONGINT;
  156.     syncSampleNum     :    LONGINT;
  157. END;
  158.  
  159. ShadowSyncAtom = RECORD
  160.     size            :    LONGINT;
  161.     atomType        :    LONGINT;
  162.     flags            :    LONGINT;
  163.     numEntries        :    LONGINT;
  164.     shadowSyncTable    :    ARRAY[0..0] OF ShadowSync;
  165. END;
  166.  
  167. SampleTableAtom = RECORD
  168.     size                :    LONGINT;    
  169.     atomType            :    LONGINT;        { = 'stbl' }
  170.     sampleDescription    :    SampleDescriptionAtom;
  171.     timeToSampleNum        :    TimeToSampleNumAtom;
  172.     sampleToChunk        :    SampleToChunkAtom;
  173.     syncSample            :    SyncSampleAtom;
  174.     sampleSize            :    SampleSizeAtom;
  175.     chunkOffset            :    ChunkOffsetAtom;
  176.     shadowSync            :    ShadowSyncAtom;
  177. END;
  178.  
  179. PublicHandlerInfo = RECORD
  180.     flags                    :    LONGINT;    { 1 byte of version / 3 bytes of flags }
  181.     componentType            :    LONGINT;            
  182.     componentSubType        :    LONGINT;                
  183.     componentManufacturer    :    LONGINT;                
  184.     componentFlags            :    LONGINT;                
  185.     componentFlagsMask        :    LONGINT;                
  186.     componentName            :    PACKED ARRAY[0..0] OF Byte;
  187. END;
  188.     
  189. HandlerAtom = RECORD
  190.     size        :    LONGINT;        
  191.     atomType    :    LONGINT;        { = 'hdlr' }
  192.     hInfo        :    PublicHandlerInfo;    
  193. END;
  194.     
  195. DataRefAtom = LONGINT;
  196.  
  197. DataInfoAtom = RECORD
  198.     size        :    LONGINT;        
  199.     atomType    :    LONGINT;            { = 'dinf' }
  200.     dataRef        :    DataRefAtom;
  201. END;
  202.  
  203. RgnAtom = RECORD
  204.     size        :    LONGINT;        
  205.     atomType    :    LONGINT;        
  206.     rgnSize        :    INTEGER;        { this is the contents of a region }
  207.     rgnBBox        :    Rect;
  208.     data        :    ARRAY[0..0] OF Byte;
  209. END;
  210.  
  211. MatteCompressedAtom = RECORD
  212.     size        :    LONGINT;                
  213.     atomType    :    LONGINT;                
  214.     flags        :    LONGINT;            { 1 byte of version / 3 bytes of flags }
  215.     matteImageDescription     :     ImageDescription;
  216.     matteData                 :    PACKED ARRAY[0..0] OF Byte;
  217. END;
  218.  
  219. MatteAtom = RECORD
  220.     size                :    LONGINT;                
  221.     atomType            :    LONGINT;            
  222.     aCompressedMatte    :    MatteCompressedAtom;
  223. END;
  224.  
  225. ClippingAtom = RECORD
  226.     size        :    LONGINT;    
  227.     atomType    :    LONGINT;        
  228.     aRgnClip    :    RgnAtom;
  229. END;
  230.     
  231. {***********************
  232. * Media Info Example Structures 
  233. ***********************}    
  234.  
  235. VideoMediaInfoHeader = RECORD
  236.     flags            :    LONGINT;        { 1 byte of version / 3 bytes of flags }
  237.     graphicsMode    :    INTEGER;        { for QD - transfer mode }
  238.     opColorRed        :    INTEGER;        { opcolor for transfer mode }
  239.     opColorGreen    :    INTEGER;
  240.     opColorBlue        :    INTEGER;
  241. END;
  242.  
  243. VideoMediaInfoHeaderAtom = RECORD
  244.     size        :    LONGINT;                { size of Media info }
  245.     atomType    :    LONGINT;                { = 'vmhd' }
  246.     vmiHeader    :    VideoMediaInfoHeader;
  247. END;
  248.  
  249. VideoMediaInfo = RECORD
  250.     size        :    LONGINT;            { size of Media info }
  251.     atomType    :    LONGINT;            { = 'minf' }
  252.     header        :    VideoMediaInfoHeaderAtom;
  253.     dataHandler    :    HandlerAtom;
  254.     dataInfo    :    DataInfoAtom;
  255.     sampleTable    :    SampleTableAtom;
  256. END;
  257.  
  258. SoundMediaInfoHeader = RECORD
  259.     flags    :    LONGINT;            { 1 byte of version / 3 bytes of flags }
  260.     balance    :    INTEGER;                
  261.     rsrvd    :    INTEGER;
  262. END;
  263.  
  264. SoundMediaInfoHeaderAtom = RECORD
  265.     size        :    LONGINT;            { size of Media info }
  266.     atomType    :    LONGINT;            { = 'vmhd' }
  267.     smiHeader    :    SoundMediaInfoHeader;    
  268. END;
  269.  
  270. SoundMediaInfo = RECORD
  271.     size            :    LONGINT;        { size of Media info }
  272.     atomType        :    LONGINT;        { = 'minf' }
  273.     header            :    SoundMediaInfoHeaderAtom;
  274.     dataHandler        :    HandlerAtom;
  275.     dataReference    :    DataRefAtom;
  276.     sampleTable        :    SampleTableAtom;
  277. END;
  278.  
  279. MediaInfo = RECORD
  280.     size        :    LONGINT;    
  281.     atomType    :    LONGINT;    
  282.     { whatever data the media handler needs goes here }
  283. END;
  284.  
  285.  
  286. {**********************
  287. * Media Directory Structures 
  288. **********************}    
  289.  
  290. MediaHeader = RECORD
  291.     flags                :    LONGINT;    { 1 byte of version / 3 bytes of flags }
  292.     creationTime        :    LONGINT;    { seconds since Jan 1904 when directory was created }
  293.     modificationTime    :    LONGINT;    { seconds since Jan 1904 when directory was appended }
  294.     timeScale            :    TimeValue;    { start time for Media (Media time) }
  295.     duration            :    TimeValue;    { length of Media (Media time) }
  296.     language            :    INTEGER;
  297.     quality                :    INTEGER;
  298. END;
  299.  
  300. MediaHeaderAtom = RECORD
  301.     size        :    LONGINT;         
  302.     atomType    :    LONGINT;                
  303.     header        :    MediaHeader;
  304. END;
  305.  
  306. MediaDirectory = RECORD
  307.     size            :    LONGINT;
  308.     atomType        :    LONGINT;            { = 'mdia' }
  309.     mediaHeader     :     MediaHeaderAtom;    { standard Media information }
  310.     mediaHandler     :     HandlerAtom;
  311.     mediaInfo        :    MediaInfo;
  312. END;
  313.  
  314. {**********************
  315. * Track Structures 
  316. **********************}    
  317.  
  318. CONST    
  319.     TrackEnable     = 1;
  320.     TrackInMovie     = 2;
  321.     TrackInPreview     = 4;
  322.     TrackInPoster     = 8;
  323.     
  324. TYPE    
  325. TrackHeader = RECORD
  326.     flags            :    LONGINT;    { 1 byte of version / 3 bytes of flags }
  327.     creationTime    :    LONGINT;    { seconds since Jan 1904 when directory was created }
  328.     modificationTime :    LONGINT;    { seconds since Jan 1904 when directory was appended }
  329.     trackID            :    LONGINT;
  330.     reserved1        :    LONGINT;
  331.     duration        :    TimeValue;    { length of track (track time) }
  332.     reserved2        :    LONGINT;
  333.     reserved3        :    LONGINT;
  334.     layer            :    INTEGER;
  335.     alternateGroup    :    INTEGER;
  336.     volume            :    INTEGER;
  337.     reserved4        :    INTEGER;
  338.     matrix            :    MatrixRecord;
  339.     trackWidth        :    Fixed;
  340.     trackHeight        :    Fixed;
  341. END;
  342.  
  343. TrackHeaderAtom = RECORD 
  344.     size        :    LONGINT;    { size of track header }
  345.     atomType    :    LONGINT;    { = 'tkhd' }
  346.     header        :    TrackHeader;
  347. END;
  348.  
  349. EditListType = RECORD 
  350.     trackDuration     :     TimeValue;
  351.     mediaTime        :    TimeValue;
  352.     mediaRate        :    Fixed;
  353. END;
  354.  
  355. EditListAtom    =    RECORD
  356.     size            :    LONGINT;
  357.     atomType        :    LONGINT;     { = elst }
  358.     flags            :    LONGINT;    { 1 byte of version / 3 bytes of flags }
  359.     numEntries        :    LONGINT;
  360.     editListTable     :     ARRAY[0..0] OF EditListType;
  361. END;
  362.  
  363. EditsAtom = RECORD
  364.     size        :    LONGINT;
  365.     atomType    :    LONGINT;    { = edts }
  366.     editList    :    EditListAtom;
  367. END;
  368.  
  369. TrackDirectory = RECORD
  370.     size            :    LONGINT;
  371.     atomType        :    LONGINT;            { = 'trak' }
  372.     trackHeader        :    TrackHeaderAtom;    { standard track information }
  373.     trackClip        :    ClippingAtom;
  374.     edits            :    EditsAtom;
  375.     media            :    MediaDirectory;
  376.      userData        :    UserDataAtom;        { space for extending with new data types }
  377. END;
  378.  
  379. MovieHeader = RECORD
  380.     flags                :    LONGINT;        { 1 byte of version / 3 bytes of flags }
  381.     creationTime        :    LONGINT;        { seconds since Jan 1904 when directory was created }
  382.     modificationTime     :    LONGINT;        { seconds since Jan 1904 when directory was appended }
  383.  
  384.     { Time specifications }
  385.     timeScale        :    TimeValue;
  386.     duration        :    TimeValue;
  387.     
  388.     preferredRate    :    Fixed;            { rate at which to play this movie }
  389.     preferredVolume    :    INTEGER;        { volume to play movie at }
  390.     reserved1        :    INTEGER;            
  391.  
  392.     { Graphics specifications }
  393.     reserved2            :    LONGINT;                    
  394.     reserved3            :    LONGINT;                    
  395.  
  396.     matrix                :    MatrixRecord;
  397.     
  398.     previewTime            :    TimeValue;        { time in track the proxy begins (track time) }
  399.     previewDuration        :    TimeValue;        { how long the proxy lasts (track time) }
  400.     posterTime             :    TimeValue;        { time in track the proxy begins (track time) }
  401.     selectionTime        :    TimeValue;        { time in track the proxy begins (track time) }
  402.     selectionDuration    :    TimeValue;        { time in track the proxy begins (track time) }
  403.     currentTime            :    TimeValue;        { time in track the proxy begins (track time) }
  404.     nextTrackID            :    LONGINT;        { next value to use for a TrackID }
  405. END;
  406.  
  407. MovieHeaderAtom = RECORD
  408.     size        :    LONGINT;
  409.     atomType    :    LONGINT;                        { = 'mvhd' }
  410.     header        :    MovieHeader;
  411. END;
  412.  
  413. MovieDirectory = RECORD
  414.     size        :    LONGINT;
  415.     atomType    :    LONGINT;                        { = 'moov' }
  416.     header        :    MovieHeaderAtom;
  417.     movieClip    :    ClippingAtom;                
  418.     { Track Directories }
  419.     track        :    RECORD
  420.                     trackDirectory : ARRAY[0..0] OF TrackDirectory;
  421.                      END;
  422.      { User data for Movie }
  423.      userData    :    UserDataAtom;                    { space for user extensions }
  424. END;
  425.  
  426. CONST
  427. { Movie formats and tags }
  428.     { some system defined format IDs }
  429.     MOVIE_TYPE    =    'moov';
  430.     TRACK_TYPE    =    'trak';
  431.     MEDIA_TYPE    =    'mdia';
  432.     VIDEO_TYPE    =    'vide';
  433.     SOUND_TYPE    =    'soun';
  434.  
  435. { atom id's }
  436.     MovieAID                =    'moov';
  437.     MovieHeaderAID            =    'mvhd';
  438.     ClipAID                    =    'clip';
  439.     RgnClipAID                =    'crgn';
  440.     MatteAID                =    'matt';
  441.     MatteCompAID            =    'kmat';
  442.     TrackAID                =    'trak';
  443.     UserDataAID                =    'udta';
  444.     TrackHeaderAID            =    'tkhd';
  445.     EditsAID                =    'edts';
  446.     EditListAID                =    'elst';
  447.     MediaAID                =    'mdia';
  448.     MediaHeaderAID            =    'mdhd';
  449.     MediaInfoAID            =    'minf';
  450.     VideoMediaInfoHeaderAID    =    'vmhd';
  451.     SoundMediaInfoHeaderAID    =    'smhd';
  452.     GenericMediaInfoHeaderAID = 'gmhd';
  453.     GenericMediaInfoAID        =    'gmin';
  454.     DataInfoAID                =    'dinf';
  455.     DataRefAID                =    'dref';
  456.     SampleTableAID            =    'stbl';
  457.     STSampleDescAID            =    'stsd';
  458.     STTimeToSampAID            =    'stts';
  459.     STSyncSampleAID            =    'stss';
  460.     STSampleToChunkAID        =    'stsc';
  461.     STShadowSyncAID            =    'stsh';
  462.     HandlerAID                =    'hdlr';
  463.     STSampleSizeAID            =    'stsz';
  464.     STChunkOffsetAID        =    'stco';
  465.     DataRefContainerAID     =    'drfc';
  466.     
  467. {$ENDC} { UsingMoviesFormat }
  468.  
  469. {$IFC NOT UsingIncludes}
  470.  END.
  471. {$ENDC}
  472.